import { parseTime, isEmpty } from './index'
import AmountUtils from '@/class/AmountUtils'

const U = {}

/**
 * 功能: 过滤日期
 * @parame:
 * @desc:
 */
U.parseTime = function(time, cFormat) {
  return parseTime(time, cFormat)
}

/**
 * 判断是否为空
 * @param value
 * @returns {boolean}  true => 为空;  false => 不为空
 */
U.isEmpty = function(val) {
  return isEmpty(val)
}

/**
 * 判断对象是否为空
 * @param obj
 * @returns {boolean}
 */
U.isObjEmpty = function(obj) {
  return Object.keys(obj).length !== 0
}

/**
 * 将对象属性 null 转 空
 * @param obj 操作的对象
 * @param delAttr  要把obj 中删除的属性数组
 * @returns {*}
 */
U.objAttrNullToString = function(obj, delAttr = []) {
  for (var keys in obj) {
    var index = delAttr.indexOf(keys)
    if (index === -1) {
      if (U.isEmpty(obj[keys])) {
        obj[keys] = ''
      }
    } else {
      delete obj[delAttr[index]]
    }
  }
  return obj
}

/**
 * null 转 字符串
 * @param data
 * @param key
 * @returns {*}
 */
U.nullToString = function(data, key) {
  if (typeof data === 'object') {
    const obj = data
    let value
    try {
      // noinspection JSAnnotator
      if (window.eval) {
        value = eval('obj.' + key)
      } else if (window.evaluate) {
        value = evaluate('obj.' + key)
      } else {
        value = data[key]
      }
      // const value = data[key]
      if (U.isEmpty(value)) {
        return ''
      }

      if (typeof value === 'boolean') {
        if (value == true || value == 'true') {
          return '是'
        } else {
          return '否'
        }
      }
      return value
    } catch (err) {
      return ''
    }
  }
  return ''
}

/**
 * 功能: 获取当天日期
 * @parame:
 * @desc:
 */
U.getNowDate = function() {
  const nowDate = new Date()
  return parseTime(nowDate)
}

/**
 * 格式化日期
 * @param date
 * @param fmt
 * @returns {*}
 */
U.formatDate = function(date, fmt) {
  if (/(y+)/.test(fmt)) {
    fmt = fmt.replace(RegExp.$1, (date.getFullYear() + '').substr(4 - RegExp.$1.length))
  }
  const o = {
    'M+': date.getMonth() + 1,
    'd+': date.getDate(),
    'h+': date.getHours(),
    'm+': date.getMinutes(),
    's+': date.getSeconds()
  }
  for (const k in o) {
    if (new RegExp(`(${k})`).test(fmt)) {
      const str = o[k] + ''
      fmt = fmt.replace(RegExp.$1, (RegExp.$1.length === 1) ? str : ('00' + str).substr(str.length))
    }
  }
  return fmt
}

/**
 * 计算天数
 * @returns {*}
 * @constructor
 * @param Date1
 * @param Date2
 */
U.DateDiff = function(Date1, Date2) {
  if (U.isEmpty(Date1)) {
    return ''
  }
  if (U.isEmpty(Date2)) {
    return ''
  }

  const sDate1 = U.cutDate(Date1)
  const sDate2 = U.cutDate(Date2)

  var aDate1, aDate2, oDate1, oDate2, iDays
  aDate1 = sDate1.split('-')
  oDate1 = new Date(aDate1[1] + '/' + aDate1[2] + '/' + aDate1[0]) // 转换为9-25-2018格式

  aDate2 = sDate2.split('-')
  oDate2 = new Date(aDate2[1] + '/' + aDate2[2] + '/' + aDate2[0])

  iDays = parseInt(Math.abs(oDate1 - oDate2) / 1000 / 60 / 60 / 24) // 把相差的毫秒数转换为天数
  // return iDays + 1
  return iDays
}

/**
 * 功能: 日期增加
 * @parame: oldDate => 需要改变的日期;  num => 需要添加的天数
 * @desc:
 * @return {Date}
 */
U.DateAddNum = function(oldDate, num) {
  let result
  if (U.isEmpty(oldDate)) {
    result = '--'
  } else {
    var now = new Date(oldDate)
    now = +now + (1000 * 60 * 60 * 24) * Number(num)
    result = new Date(now)
  }
  return result
}

/**
 * 首字母 转 大写字母 和  大写转小写
 * @param first
 * @param rest
 * @param lowerRest
 * @returns {string}
 */
U.capitalize = function([first, ...rest], lowerRest = false) {
  return first.toUpperCase() + (lowerRest ? rest.join('').toLowerCase() : rest.join(''))
}

// 首字母 转 小写字母 和  小写转大写
U.lowercase = function([first, ...rest], lowerRest = false) {
  return first.toLowerCase() + (lowerRest ? rest.join('').toLowerCase() : rest.join(''))
}

/**
 * obj 深度拷贝
 * @param source
 * @returns {*}
 */
U.deepCopy = function(source) {
  if (!source && typeof source !== 'object') {
    throw new Error('error arguments', 'deepClone')
  }
  const targetObj = source.constructor === Array ? [] : {}
  Object.keys(source).forEach(keys => {
    if (source[keys] && typeof source[keys] === 'object') {
      targetObj[keys] = U.deepCopy(source[keys])
    } else {
      targetObj[keys] = source[keys]
    }
  })
  return targetObj
}

/**
 * 表格根据页面排序
 * @param pageSize 显示的条数
 * @param pageNumber 显示的页码
 * @param total 总数
 * @param data 显示的数据
 */
U.tableNumber = function(pageSize, pageNumber, total, data) {
  // 开始条数
  var start = (pageNumber - 1) * pageSize + 1
  // 结束条数
  var end = start + (pageSize - 1)
  if (end > total) {
    end = total
  }
  var pageListLen = data.length
  for (var i = 0; i < pageListLen; i++) {
    data[i].index = start + i
  }
}

/**
 *  金额 添加 千位符
 * @param amount
 * @returns {string}
 */
U.toThousands = function(amount) {
  return AmountUtils.toThousands(amount)
}

/**
 * 元转分 == 分转元
 * @param money  需要转的值
 * @param symbol  需要转的符号  / 和 *
 * @returns {*}
 */
U.moneyUtilTransform = function(money, symbol = '/') {
  if (symbol === '/') {
    return AmountUtils.unitTransfer(money, 'P', 'Y', 2)
  } else {
    return AmountUtils.unitTransfer(money, 'Y', 'P', 2)
  }
}

/**
 *  数值保留N位小数, 四舍五入
 * @param num 需要转换的数值
 * @param digit  需要保留的位数 默认保存六位
 * @returns {*}
 */
U.retainNumber = function(num, digit = 2) {
  // 判断是否为空
  if (U.isEmpty(num)) {
    return num
  }
  var f = parseFloat(num)
  if (isNaN(f) || f.toString().length !== num.toString().length) {
    return num
  } else {
    return f.toFixed(digit)
  }
}

/**
 * 判断两个对象是否相等
 * @param oldData 旧对象
 * @param newData 新对象
 * @returns {boolean}
 */
U.equalsObj = function(oldData, newData) {
// 类型为基本类型时,如果相同,则返回true
  if (oldData === newData) return true
  // 类型为对象并且元素个数相同
  if (U.isObject(oldData) && U.isObject(newData) && Object.keys(oldData).length === Object.keys(newData).length) {
    // 遍历所有对象中所有属性,判断元素是否相同
    for (const key in oldData) {
      if (oldData.hasOwnProperty(key)) {
        if (!U.equalsObj(oldData[key], newData[key])) { // 对象中具有不相同属性 返回false
          return false
        }
      }
    }
    // 类型为数组并且数组长度相同
  } else if (U.isArray(oldData) && U.isArray(oldData) && oldData.length === newData.length) {
    for (let i = 0, length = oldData.length; i < length; i++) {
      // 如果数组元素中具有不相同元素,返回false
      if (!U.equalsObj(oldData[i], newData[i])) { return false }
    }
  } else {
    // 其它类型,均返回false
    return false
  }

  // 走到这里,说明数组或者对象中所有元素都相同,返回true
  return true
}

/**
 * 判断是否为对象
 * @param obj
 * @returns {boolean}
 */
U.isObject = function(obj) {
  return Object.prototype.toString.call(obj) === '[object Object]'
}

/**
 * 判断是否为数组
 * @param arr 数据
 * @returns {boolean}
 */
U.isArray = function(arr) {
  return Object.prototype.toString.call(arr) === '[object Array]'
}

/** *
 * 功能: 重置iFrame 高度(屏幕的高度)
 * @param id
 */
U.changeFrameHeight = function(id) {
  var ifm = document.getElementById(id)
  if (!ifm) return
  ifm.height = document.documentElement.clientHeight - 56
  window.onresize = function() { U.changeFrameHeight(id) }
}

/**
 * 功能: 字符串拼接
 * @parame:
 * @desc:
 * str: 资产到期XX天前
 * value: 4
 *
 * res: 资产到期4天前
 */
U.strJoin = function(value, str) {
  if (U.isEmpty(value)) {
    return '--'
  } else if (U.isEmpty(str)) {
    return value
  } else {
    return str.replace(/\bXX\b/g, value)
  }
}

/**
 * 功能: 单词 -- 下划线转驼峰
 * @parame:
 * @desc:
 */
U.underlineToHump = function(value) {
  if (value.indexOf('_') > -1) {
    const values = value.split('_')
    let newValue = ''
    values.forEach((item, index) => {
      if (index === 0) {
        newValue = item
      } else {
        newValue = newValue + item.replace(item[0], item[0].toUpperCase())
        // newValue = newValue + item.toUpperCase()
      }
    })
    return newValue
  } else {
    return value
  }
}

/**
 * 功能: 对象中的 key 下划线转驼峰
 * @parame:
 * @desc:
 */
U.objKeyUnderlineToHump = function(obj) {
  if (Object.keys(obj).length > 0) {
    const newObj = {}
    for (const key in obj) {
      const newKey = U.underlineToHump(key)
      newObj[newKey] = obj[key]
      newObj[key] = obj[key]
    }
    return newObj
  } else {
    return obj
  }
}

export default U
